package com.yidu.hbatsams.action;

import com.yidu.hbatsams.domain.*;

import com.yidu.hbatsams.service.emp.AtsEmpAthleteService;
import com.yidu.hbatsams.service.emp.AtsEmpExpertService;
import com.yidu.hbatsams.service.AtsSchemeImpl;
import com.yidu.hbatsams.utils.FileTools;
import com.yidu.hbatsams.utils.Message;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;


import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.*;

@Controller
@RequestMapping("/AtsSchemeController")
public class AtsSchemeController {

    @Resource
    FileTools fileTools;

    @Resource
    AtsSchemeImpl schemeImpl;

    @Resource
    AtsEmpAthleteService atsEmpAthleteService;


    @ResponseBody
    @RequestMapping("/selectAll")
    public Map<String,Object> findAll(AtsScheme atsScheme,@RequestParam("page") Integer pageNum,@RequestParam("limit") Integer pageSize){
        System.out.println("id为"+atsScheme.getCoachId());//测试输出语句 输出方案表教练员的id
        Map<String,Object> map = new HashMap<String,Object>(); //创建一个HashMap集合
        List<AtsScheme> atsSchemes = schemeImpl.selectAll(atsScheme,pageNum,pageSize);//调用查询全部的方法
        map.put("data",atsSchemes);//给data赋值
        map.put("code",0);//将code值设为0
        map.put("count",schemeImpl.selectAllCount(atsScheme));//给count赋schemeImpl中查询全部数据行数的值
        map.put("msg","");//将msg值设为空
        return map;//返回map值
    }


    @RequestMapping("/updateByPrimaryKeySelective")
    @ResponseBody
    public Message update(AtsScheme atsScheme,@RequestParam(value = "resultFiles", required = false) MultipartFile resultFiles) throws IOException {
        //通过fileTools的保存文件方法得到服务器name的upload文件夹的地址
        String name = fileTools.saveFile("kffa",resultFiles);
        atsScheme.setResultFile(name);//将值放入方案表的反馈文件流中
        int count = schemeImpl.updateByPrimaryKeySelective(atsScheme);//调用修改方法
        Message st=new Message();//创建一个消息对象
        if(count>0){ //判断返回值是否修改成功
            st.setMsg("反馈成功");//成功
            return st; //返回
        }else{
            st.setMsg("反馈失败");//失败
            return st;//返回
        }
    }

    @ResponseBody
    @RequestMapping("/add")
    public Message add(@RequestParam(value = "f1", required = false) MultipartFile f1,@RequestParam(value = "f2", required = false) MultipartFile f2,@RequestParam(value = "f3", required = false) MultipartFile f3 ,Integer[] athleteName,String mothed, AtsScheme atsScheme,Integer schemeId, HttpSession session) throws IOException {
        //得到服务器的upload文件夹的地址
        atsScheme.setCreatTime(new Date()); //创建一个日期对象赋值于方案表的创建时间
        String name1 = fileTools.saveFile("kffa",f1); //通过fileTools的保存文件方法得到服务器name1的upload文件夹的地址
        String name2 = fileTools.saveFile("kffa",f2); //通过fileTools的保存文件方法得到服务器name2的upload文件夹的地址
        String name3 = fileTools.saveFile("kffa",f3); //通过fileTools的保存文件方法得到服务器name3的upload文件夹的地址
        atsScheme.setFile1(name1);  //将值放入方案表的文件1流中
        atsScheme.setFile2(name2); //将值放入方案表的文件2流中
        atsScheme.setFile3(name3); //将值放入方案表的文件3流中
        if(mothed.equals("") || mothed == null){ //如果mothed的值为空
            //调用schemeImpl的插入方法并将得到的值放入到消息对象中
            Message mg= schemeImpl.insertSelective(atsScheme);

            for(int i=0,len=athleteName.length;i<len;i++){  //使用for循环，循环次数为athleteName的长度
                AtsSchemeAthlete atsSchemeAthlete = new AtsSchemeAthlete(); //创建一个AtsSchemeAthlete对象
                atsSchemeAthlete.setIsRead("未查看");//设置IsRead为‘未查看’
                atsSchemeAthlete.setSchemeId(mg.getNum());//将mg中的num赋值到SchemeId
                atsSchemeAthlete.setSchemeName(atsScheme.getSchemeName());//设置方案名，从atsScheme对象中获取
                atsSchemeAthlete.setAthleteId(athleteName[i]);//将athleteName[i]设为运动员id
                atsSchemeAthlete.setAthleteName(schemeImpl.selectAts(athleteName[i]).getAthleteName());//调用schemeImpl中的selectAts方法将athleteName[i]传参得到运动员姓名，再赋值运动员姓名
                atsSchemeAthlete.setIsva(atsScheme.getIsva());//将tsSchemeAthlete的Isva与atsScheme同步
                schemeImpl.insertAtsSchemeAthlete(atsSchemeAthlete);//再调用schemeImpl中的insertAtsSchemeAthlete，将atsSchemeAthlete传过去
            }

            return mg;//返回mg
        }else{
            //调用schemeImpl的修改方法并将得到的值放入到整数result中
            int result = schemeImpl.updateByPrimaryKeySelective(atsScheme);

            //调用schemeImpl中的删除运动员id来清空之前选择的运动员
            int count = schemeImpl.deleteAthleteId(schemeId);
            for(int i=0,len=athleteName.length;i<len;i++){ //使用for循环，循环次数为athleteName的长度
                AtsSchemeAthlete atsSchemeAthlete = new AtsSchemeAthlete(); //创建一个AtsSchemeAthlete对象
                atsSchemeAthlete.setSchemeId(schemeId); //将方案id放入到atsSchemeAthlete的方案id中
                atsSchemeAthlete.setSchemeName(atsScheme.getSchemeName());//设置方案名，从atsScheme对象中获取
                atsSchemeAthlete.setAthleteId(athleteName[i]);//将athleteName[i]设为运动员id
                atsSchemeAthlete.setAthleteName(schemeImpl.selectAts(athleteName[i]).getAthleteName());//调用schemeImpl中的selectAts方法将athleteName[i]传参得到运动员姓名，再赋值运动员姓名
                atsSchemeAthlete.setIsva(atsScheme.getIsva());//将tsSchemeAthlete的Isva与atsScheme同步
                schemeImpl.insertAtsSchemeAthlete(atsSchemeAthlete);//再调用schemeImpl中的insertAtsSchemeAthlete，将atsSchemeAthlete传过去
            }

            Message msg = new Message();//创建一个消息对象

            if(result > 0 ){ //如果result大于0

                msg.setNum(result); //将result放入到msg的num中
                msg.setMsg("操作成功"); //将操作成功的消息放入其中
            }

            return msg; //返回msg
        }


    }

    /**
     * 查询所有运动员
     * @return
     */
    @ResponseBody
    @RequestMapping("/selectAthletes")
    public List<AtsEmpAthlete> selectAthletes(){

        return schemeImpl.selectAllAts();//返回schemeImpl中的selectAllAts方法中的值
    }

    /**
     * 根据教练员id查询运动员
     * @param coachId
     * @return AtsEmpCoachAthlete
     */
    @ResponseBody
    @RequestMapping("/selectAthlete")
    public List<AtsEmpAthlete> selectAthlete(Integer coachId){
        List<AtsEmpAthlete> empAthleteList=atsEmpAthleteService.selectByCoachId(coachId);//调用atsEmpAthleteService的查找教练员id使用List<AtsEmpAthlete>接收
        return empAthleteList; //返回
    }

    /**
     * 删除
     * @param schemeId
     * @return AtsEmpCoachAthlete
     */
    @ResponseBody
    @RequestMapping("/deleteScheme")
    public Message deleteScheme(Integer schemeId,Integer[] schemeIds){
        Message gs = new Message();//创建一个消息对象
        if(schemeIds==null||schemeIds.length==0){//判断schemeIds是否为空或者长度是否为空

            int result = schemeImpl.deleteScheme(schemeId);//根据schemeId删除方案使用result接收
            int count = schemeImpl.updateIsva(schemeId);//根据schemeId修改方案是否有效使用count接收
            if (result>0 && count>0){ //如果都大于0
                gs.setNum(1); //将gs中的num值设为1
                gs.setMsg("删除成功");//删除成功
            }else{
                gs.setNum(0);//如果不成功则将gs中的num值设为0
            }
            return gs;//返回gs
        }else{ //如果为空

            schemeImpl.deleteScheme(schemeIds);//则根据schemeIds删除方案
            schemeImpl.updateIsva(schemeIds);//根据schemeIds修改方案是否有效
            return null;//返回null
        }

    }

    @ResponseBody
    @RequestMapping("/selectAthleteName")
    public List<AtsSchemeAthlete> selectAthleteName(Integer schemeId){

        return schemeImpl.selectschemeId(schemeId);//返回schemeImpl中的搜索方案id方法
    }

    @ResponseBody
    @RequestMapping("/updateAtsSchemeAthlete")
    public void updateAtsSchemeAthlete(AtsSchemeAthlete atsSchemeAthlete){
        schemeImpl.updateAtsSchemeAthlete(atsSchemeAthlete);//调用schemeImpl中的修改updateAtsSchemeAthlete方法
    }

    @ResponseBody
    @RequestMapping("/updateAtsSchemeAthletes")
    public Message updateAtsSchemeAthletes(AtsSchemeAthlete atsSchemeAthlete){
        int count = schemeImpl.updateAtsSchemeAthletes(atsSchemeAthlete);//使用整数count接收schemeImpl的修改方案对应的运动员表
        Message mg = new Message();//创建一个消息对象
        if(count>0){ //如果count大于0
            mg.setMsg("已提交"); //保存已提交
        }else{ //否则
            mg.setMsg("网络不行");//保存网络不行
        }
        return mg;//返回mg
    }

    /**
     * 给专家咨询表增加数据
     * @param atsSchemeExpert
     * @return Message
     */
    @ResponseBody
    @RequestMapping("/atsSchemeExpertInsert")
    public Message atsSchemeExpertInsert(AtsSchemeExpert atsSchemeExpert){
        int count = schemeImpl.atsSchemeExpertInsert(atsSchemeExpert);//调用schemeImpl中的atsSchemeExpertInsert方法使用整数count接收
        Message ag = new Message();//创建一个消息对象
        if (count>0){ //如果count大于0
            ag.setMsg("申请成功"); //申请成功
        }else { //否则
            ag.setMsg("申请失败"); //申请失败
        }
        return ag; //返回消息对象
    }

    /**
     * 查询方案是否已被申请过
     * @param schemeId
     * @return Message
     */
    @ResponseBody
    @RequestMapping("/selectExist")
    public List<AtsSchemeExpert> selectExist(Integer schemeId){
        return schemeImpl.selectExist(schemeId); //调用schemeImpl中的搜索存在方法
    }

    /**
     * 查询所有专家
     * @return List<AtsEmpExpert>
     */
    @ResponseBody
    @RequestMapping("/selectAtsEmpExpert")
    public List<AtsEmpExpert> selectAtsEmpExpert(){

        List<AtsEmpExpert> AtsEmpExperts = schemeImpl.selectAtsEmpExpert(); //调用schemeImpl中的查询方法，使用集合接收

        return AtsEmpExperts;//返回集合
    }

    /**
     * 给审核表增加数据
     * @return Message
     */
    @ResponseBody
    @RequestMapping("/atsSchemeAuditMapperInsert")
    public Message atsSchemeAuditMapperInsert(AtsSchemeAudit atsSchemeAudit,AtsSchemeExpert atsSchemeExpert){
        String[] array = atsSchemeExpert.getExpertName().split(",");//将atsSchemeExpert中的专家信息分割成一个String数组
        atsSchemeExpert.setExpertId(Integer.valueOf(array[0]));//将数组中的第一个专家id转成整数后放入atsSchemeExpert的专家id中
        atsSchemeExpert.setExpertName(array[1]);//将数组中的第二个专家姓名放入atsSchemeExpert的专家姓名中
        atsSchemeExpert.setSchemeId(Integer.valueOf(atsSchemeAudit.getSaId()));//将审核表的SaId转成整数后反放入atsSchemeExpert的方案id中
        Message mg = schemeImpl.atsSchemeAuditMapperInsert(atsSchemeAudit,atsSchemeExpert);//调用schemeImpl中审核表映射插入方法，将两个对象传入其中，使用消息对象接收
        return mg;//返回消息对象
    }

    /**
     * 给根据业务id查询审核表
     * @return Message
     */
    @ResponseBody
    @RequestMapping("/atsSchemeAuditSelectBySaId")
    public List<AtsSchemeAudit> atsSchemeAuditSelectBySaId(String saId){
        List<AtsSchemeAudit> atsSchemeAudit = schemeImpl.atsSchemeAuditSelectBySaId(saId);//调用schemeImpl中审核表查询方案id方法
        return atsSchemeAudit;//返回集合
    }

    /**
     * 修改专家咨询表
     * @return Message
     */
    @ResponseBody
    @RequestMapping("/atsSchemeExpertUpdateByPrimaryKeySelective")
    public Message atsSchemeExpertUpdateByPrimaryKeySelective(AtsSchemeExpert atsSchemeExpert){
        int count = schemeImpl.atsSchemeExpertUpdateByPrimaryKeySelective(atsSchemeExpert);//调用schemeImpl中方法
        Message ag = new Message();//创建一个消息对象
        if (count>0){ //如果count大于0
            ag.setMsg("已回复"); //保存已回复
        }else { //否则
            ag.setMsg("回复失败");//保存回复失败
        }
        return ag; //返回消息对象
    }

    /**
     * 根据id查询方案表
     * @param schemeId
     * @return AtsScheme
     */
    @ResponseBody
    @RequestMapping("/selectByschemeId")
    public AtsScheme selectByschemeId(Integer schemeId){
        return schemeImpl.selectByPrimaryKey(schemeId);//返回schemeImpl的查询主键方法
    }


    /**
     * 查询审核表
     * @return List<AtsSchemeAudit>
     */
    @ResponseBody
    @RequestMapping("/selectAtsSchemeAudit")
    public List<AtsSchemeAudit> selectAtsSchemeAudit(){
        return schemeImpl.selectAtsSchemeAudit();//调用方法
    }

    /**
     * 字段赋值
     * @param atsScheme
     */
    @ResponseBody
    @RequestMapping("/updateAuditState")
    public void updateAuditState(AtsScheme atsScheme){
        if(atsScheme.getRemark() != null){//如果方案表的评论字段不为空时
            String[] array = atsScheme.getRemark().split(","); //将字段根据“，”分割保存在数组中
            atsScheme.setRemark(array[0]);//将数组中第一个数据保存到评论字段中
        }

        schemeImpl.updateByPrimaryKeySelective(atsScheme);//调用schemeImpl中的修改方法
    }


    /**
     * 删除审核表中上次申请的结果
     * @param atsSchemeAudit
     */
    @ResponseBody
    @RequestMapping("/updateAtsSchemeAudit")
    public void updateAtsSchemeAudit(AtsSchemeAudit atsSchemeAudit){
        schemeImpl.updateAtsSchemeAudit(atsSchemeAudit);//调用修改审核表
    }

    /**
     * 根据运动员id查询信息
     * @param
     */
    @ResponseBody
    @RequestMapping("/selectAthletees")
    public Map<String,Object> selectAthlete(AtsScheme atsScheme,@RequestParam("page") Integer pageNum,@RequestParam("limit") Integer pageSize,Integer athleteId){
        List<AtsSchemeAthlete> ats = schemeImpl.selectByAthleteId(athleteId);//调用schemeImpl搜索运动员id的方法
        String schemeIdes = "";//创建一个schemeIdes的字符串
        for (AtsSchemeAthlete at : ats) { //循环ats集合
            schemeIdes += at.getSchemeId()+","; //将集合中的方案id拼接保存到schemeIdes中
        }
        String regex = "^,*|,*$";//定义正则 "^,*|,*$"
        String schemeIds = schemeIdes.replaceAll(regex, ""); //将schemeIdes使用替换全部方法将正则和""放入其中
        System.out.println(schemeIds);//测试输出schemeIds
        Map map = new HashMap();//创建一个HashMap对象
        map.put("ids",schemeIds.split(","));//将schemeIds根据“，”分割后保存到map集合中，命名为ids
        List<AtsScheme> atsSchemes = schemeImpl.selectByPrimaryKeyAthlete(map,pageNum,pageSize);//调用schemeImpl中查询主键运动员的方法将map与页码与页码尺寸传入其中


        Map<String,Object> maps = new HashMap<String,Object>();//创建maps对象

        maps.put("data",atsSchemes);//将atsSchemes放入maps集合中，命名data
        maps.put("code",0);//将0放入maps集合中，命名code
        maps.put("count",schemeImpl.selectByPrimaryKeyAthleteCount(map));//调用schemeImpl中查询主键运动员页码中传参map后放入maps集合中，命名count
        maps.put("msg","");//将""放入maps集合中，命名msg
        return maps;//返回maps
    }
}
